
<!DOCTYPE html>

<html>
  
<!-- Mirrored from docs.sympy.org/latest/modules/physics/continuum_mechanics/beam.html by HTTrack Website Copier/3.x [XR&CO'2014], Sat, 15 Jan 2022 03:27:05 GMT -->
<!-- Added by HTTrack --><meta http-equiv="content-type" content="text/html;charset=utf-8" /><!-- /Added by HTTrack -->
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />

    <title>Beam (Docstrings) &#8212; SymPy 1.9 documentation</title>
    <link rel="stylesheet" type="text/css" href="../../../_static/pygments.css" />
    <link rel="stylesheet" type="text/css" href="../../../_static/default.css" />
    <link rel="stylesheet" type="text/css" href="../../../_static/graphviz.css" />
    <link rel="stylesheet" type="text/css" href="../../../_static/plot_directive.css" />
    <link rel="stylesheet" type="text/css" href="../../../../../live.sympy.org/static/live-core.css" />
    <link rel="stylesheet" type="text/css" href="../../../../../live.sympy.org/static/live-autocomplete.css" />
    <link rel="stylesheet" type="text/css" href="../../../../../live.sympy.org/static/live-sphinx.css" />
    
    <script data-url_root="../../../" id="documentation_options" src="../../../_static/documentation_options.js"></script>
    <script src="../../../_static/jquery.js"></script>
    <script src="../../../_static/underscore.js"></script>
    <script src="../../../_static/doctools.js"></script>
    <script src="../../../../../live.sympy.org/static/utilities.js"></script>
    <script src="../../../../../live.sympy.org/static/external/classy.js"></script>
    <script src="../../../../../live.sympy.org/static/live-core.js"></script>
    <script src="../../../../../live.sympy.org/static/live-autocomplete.js"></script>
    <script src="../../../../../live.sympy.org/static/live-sphinx.js"></script>
    <script async="async" src="../../../../../cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest8331.js?config=TeX-AMS_HTML-full"></script>
    <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["\\(", "\\)"]], "displayMath": [["\\[", "\\]"]]}})</script>
    
    <link rel="shortcut icon" href="../../../_static/sympy-notailtext-favicon.ico"/>
    <link href="beam.html" rel="canonical" />
    
    <link rel="index" title="Index" href="../../../genindex.html" />
    <link rel="search" title="Search" href="../../../search.html" />
    <link rel="next" title="Solving Beam Bending Problems using Singularity Functions" href="beam_problems.html" />
    <link rel="prev" title="Continuum Mechanics" href="index.html" /> 
  </head><body>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../../../genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="../../../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="beam_problems.html" title="Solving Beam Bending Problems using Singularity Functions"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="index.html" title="Continuum Mechanics"
             accesskey="P">previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="../../../index.html">SymPy 1.9 documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="../../index.html" >SymPy Modules Reference</a> &#187;</li>
          <li class="nav-item nav-item-2"><a href="../index.html" >Physics</a> &#187;</li>
          <li class="nav-item nav-item-3"><a href="index.html" accesskey="U">Continuum Mechanics</a> &#187;</li>
        <li class="nav-item nav-item-this"><a href="#">Beam (Docstrings)</a></li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body" role="main">
            
  <section id="beam-docstrings">
<h1>Beam (Docstrings)<a class="headerlink" href="#beam-docstrings" title="Permalink to this headline">¶</a></h1>
<section id="module-sympy.physics.continuum_mechanics.beam">
<span id="beam"></span><h2>Beam<a class="headerlink" href="#module-sympy.physics.continuum_mechanics.beam" title="Permalink to this headline">¶</a></h2>
<p>This module can be used to solve 2D beam bending problems with
singularity functions in mechanics.</p>
<dl class="py class">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam">
<em class="property"><span class="pre">class</span> </em><span class="sig-prename descclassname"><span class="pre">sympy.physics.continuum_mechanics.beam.</span></span><span class="sig-name descname"><span class="pre">Beam</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">length</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">elastic_modulus</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">second_moment</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">area</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">A</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">variable</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">x</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">base_char</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'C'</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L22-L2300"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam" title="Permalink to this definition">¶</a></dt>
<dd><p>A Beam is a structural element that is capable of withstanding load
primarily by resisting against bending. Beams are characterized by
their cross sectional profile(Second moment of area), their length
and their material.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>While solving a beam bending problem, a user should choose its
own sign convention and should stick to it. The results will
automatically follow the chosen sign convention. However, the
chosen sign convention must respect the rule that, on the positive
side of beam’s axis (in respect to current section), a loading force
giving positive shear yields a negative moment, as below (the
curved arrow shows the positive moment and rotation):</p>
</div>
<img alt="../../../_images/allowed-sign-conventions.png" src="../../../_images/allowed-sign-conventions.png" />
<p class="rubric">Examples</p>
<p>There is a beam of length 4 meters. A constant distributed load of 6 N/m
is applied from half of the beam till the end. There are two simple supports
below the beam, one at the starting point and another at the ending point
of the beam. The deflection of the beam at the end is restricted.</p>
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span><span class="p">,</span> <span class="n">Piecewise</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">boundary_conditions</span>
<span class="go">{&#39;deflection&#39;: [(0, 0), (4, 0)], &#39;slope&#39;: []}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">R1*SingularityFunction(x, 0, -1) + R2*SingularityFunction(x, 4, -1) + 6*SingularityFunction(x, 2, 0)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">-3*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 2, 0) - 9*SingularityFunction(x, 4, -1)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">shear_force</span><span class="p">()</span>
<span class="go">3*SingularityFunction(x, 0, 0) - 6*SingularityFunction(x, 2, 1) + 9*SingularityFunction(x, 4, 0)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bending_moment</span><span class="p">()</span>
<span class="go">3*SingularityFunction(x, 0, 1) - 3*SingularityFunction(x, 2, 2) + 9*SingularityFunction(x, 4, 1)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">slope</span><span class="p">()</span>
<span class="go">(-3*SingularityFunction(x, 0, 2)/2 + SingularityFunction(x, 2, 3) - 9*SingularityFunction(x, 4, 2)/2 + 7)/(E*I)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">deflection</span><span class="p">()</span>
<span class="go">(7*x - SingularityFunction(x, 0, 3)/2 + SingularityFunction(x, 2, 4)/4 - 3*SingularityFunction(x, 4, 3)/2)/(E*I)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">deflection</span><span class="p">()</span><span class="o">.</span><span class="n">rewrite</span><span class="p">(</span><span class="n">Piecewise</span><span class="p">)</span>
<span class="go">(7*x - Piecewise((x**3, x &gt; 0), (0, True))/2</span>
<span class="go">     - 3*Piecewise(((x - 4)**3, x - 4 &gt; 0), (0, True))/2</span>
<span class="go">     + Piecewise(((x - 2)**4, x - 2 &gt; 0), (0, True))/4)/(E*I)</span>
</pre></div>
</div>
<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.applied_loads">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">applied_loads</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.applied_loads" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a list of all loads applied on the beam object.
Each load in the list is a tuple of form (value, start, order, end).</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 4 meters. A moment of magnitude 3 Nm is
applied in the clockwise direction at the starting point of the beam.
A pointload of magnitude 4 N is applied from the top of the beam at
2 meters from the starting point. Another pointload of magnitude 5 N
is applied at same position.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">-3*SingularityFunction(x, 0, -2) + 9*SingularityFunction(x, 2, -1)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">applied_loads</span>
<span class="go">[(-3, 0, -2, None), (4, 2, -1, None), (5, 2, -1, None)]</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.apply_load">
<span class="sig-name descname"><span class="pre">apply_load</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">start</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">end</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L422-L488"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.apply_load" title="Permalink to this definition">¶</a></dt>
<dd><p>This method adds up the loads given to a particular beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>value</strong> : Sympifyable</p>
<blockquote>
<div><p>The value inserted should have the units [Force/(Distance**(n+1)]
where n is the order of applied load.
Units for applied loads:</p>
<blockquote>
<div><ul class="simple">
<li><p>For moments, unit = kN*m</p></li>
<li><p>For point loads, unit = kN</p></li>
<li><p>For constant distributed load, unit = kN/m</p></li>
<li><p>For ramp loads, unit = kN/m/m</p></li>
<li><p>For parabolic ramp loads, unit = kN/m/m/m</p></li>
<li><p>… so on.</p></li>
</ul>
</div></blockquote>
</div></blockquote>
<p><strong>start</strong> : Sympifyable</p>
<blockquote>
<div><p>The starting point of the applied load. For point moments and
point forces this is the location of application.</p>
</div></blockquote>
<p><strong>order</strong> : Integer</p>
<blockquote>
<div><p>The order of the applied load.</p>
<blockquote>
<div><ul class="simple">
<li><p>For moments, order = -2</p></li>
<li><p>For point loads, order =-1</p></li>
<li><p>For constant distributed load, order = 0</p></li>
<li><p>For ramp loads, order = 1</p></li>
<li><p>For parabolic ramp loads, order = 2</p></li>
<li><p>… so on.</p></li>
</ul>
</div></blockquote>
</div></blockquote>
<p><strong>end</strong> : Sympifyable, optional</p>
<blockquote>
<div><p>An optional argument that can be used if the load has an end point
within the length of the beam.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 4 meters. A moment of magnitude 3 Nm is
applied in the clockwise direction at the starting point of the beam.
A point load of magnitude 4 N is applied from the top of the beam at
2 meters from the starting point and a parabolic ramp load of magnitude
2 N/m is applied below the beam starting from 2 meters to 3 meters
away from the starting point of the beam.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">-3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) - 2*SingularityFunction(x, 2, 2) + 2*SingularityFunction(x, 3, 0) + 4*SingularityFunction(x, 3, 1) + 2*SingularityFunction(x, 3, 2)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.apply_support">
<span class="sig-name descname"><span class="pre">apply_support</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">loc</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'fixed'</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L361-L420"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.apply_support" title="Permalink to this definition">¶</a></dt>
<dd><p>This method applies support to a particular beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>loc</strong> : Sympifyable</p>
<blockquote>
<div><p>Location of point at which support is applied.</p>
</div></blockquote>
<p><strong>type</strong> : String</p>
<blockquote>
<div><p>Determines type of Beam support applied. To apply support structure
with
- zero degree of freedom, type = “fixed”
- one degree of freedom, type = “pin”
- two degrees of freedom, type = “roller”</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 30 meters. A moment of magnitude 120 Nm is
applied in the clockwise direction at the end of the beam. A pointload
of magnitude 8 N is applied from the top of the beam at the starting
point. There are two simple supports below the beam. One at the end
and another one at a distance of 10 meters from the start. The
deflection is restricted at both the supports.</p>
<p>Using the sign convention of upward forces and clockwise moment
being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">120</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R_10</span><span class="p">,</span> <span class="n">R_30</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R_10, R_30&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R_10</span><span class="p">,</span> <span class="n">R_30</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">-8*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 10, -1)</span>
<span class="go">+ 120*SingularityFunction(x, 30, -2) + 2*SingularityFunction(x, 30, -1)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">slope</span><span class="p">()</span>
<span class="go">(-4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2)</span>
<span class="go">    + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + 4000/3)/(E*I)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.area">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">area</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.area" title="Permalink to this definition">¶</a></dt>
<dd><p>Cross-sectional area of the Beam.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.bending_moment">
<span class="sig-name descname"><span class="pre">bending_moment</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L929-L961"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.bending_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a Singularity Function expression which represents
the bending moment curve of the Beam object.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 30 meters. A moment of magnitude 120 Nm is
applied in the clockwise direction at the end of the beam. A pointload
of magnitude 8 N is applied from the top of the beam at the starting
point. There are two simple supports below the beam. One at the end
and another one at a distance of 10 meters from the start. The
deflection is restricted at both the supports.</p>
<p>Using the sign convention of upward forces and clockwise moment
being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">120</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bending_moment</span><span class="p">()</span>
<span class="go">8*SingularityFunction(x, 0, 1) - 6*SingularityFunction(x, 10, 1) - 120*SingularityFunction(x, 30, 0) - 2*SingularityFunction(x, 30, 1)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.boundary_conditions">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">boundary_conditions</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.boundary_conditions" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a dictionary of boundary conditions applied on the beam.
The dictionary has three keywords namely moment, slope and deflection.
The value of each keyword is a list of tuple, where each tuple
contains location and value of a boundary condition in the format
(location, value).</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 4 meters. The bending moment at 0 should be 4
and at 4 it should be 0. The slope of the beam should be 1 at 0. The
deflection should be 2 at 0.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_slope</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">boundary_conditions</span>
<span class="go">{&#39;deflection&#39;: [(0, 2)], &#39;slope&#39;: [(0, 1)]}</span>
</pre></div>
</div>
<p>Here the deflection of the beam should be <code class="docutils literal notranslate"><span class="pre">2</span></code> at <code class="docutils literal notranslate"><span class="pre">0</span></code>.
Similarly, the slope of the beam should be <code class="docutils literal notranslate"><span class="pre">1</span></code> at <code class="docutils literal notranslate"><span class="pre">0</span></code>.</p>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.cross_section">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">cross_section</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.cross_section" title="Permalink to this definition">¶</a></dt>
<dd><p>Cross-section of the beam</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.deflection">
<span class="sig-name descname"><span class="pre">deflection</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1125-L1254"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.deflection" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a Singularity Function expression which represents
the elastic curve or deflection of the Beam object.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 30 meters. A moment of magnitude 120 Nm is
applied in the clockwise direction at the end of the beam. A pointload
of magnitude 8 N is applied from the top of the beam at the starting
point. There are two simple supports below the beam. One at the end
and another one at a distance of 10 meters from the start. The
deflection is restricted at both the supports.</p>
<p>Using the sign convention of upward forces and clockwise moment
being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">120</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">deflection</span><span class="p">()</span>
<span class="go">(4000*x/3 - 4*SingularityFunction(x, 0, 3)/3 + SingularityFunction(x, 10, 3)</span>
<span class="go">    + 60*SingularityFunction(x, 30, 2) + SingularityFunction(x, 30, 3)/3 - 12000)/(E*I)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.draw">
<span class="sig-name descname"><span class="pre">draw</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">pictorial</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2072-L2156"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.draw" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot object representing the beam diagram of the beam.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The user must be careful while entering load values.
The draw function assumes a sign convention which is used
for plotting loads.
Given a right handed coordinate system with XYZ coordinates,
the beam’s length is assumed to be along the positive X axis.
The draw function recognizes positve loads(with n&gt;-2) as loads
acting along negative Y direction and positve moments acting
along positive Z direction.</p>
</div>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>pictorial: Boolean (default=True)</strong></p>
<blockquote>
<div><p>Setting <code class="docutils literal notranslate"><span class="pre">pictorial=True</span></code> would simply create a pictorial (scaled) view
of the beam diagram not with the exact dimensions.
Although setting <code class="docutils literal notranslate"><span class="pre">pictorial=False</span></code> would create a beam diagram with
the exact dimensions on the plot</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">50</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">30</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">90</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">23</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">50</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">50</span><span class="p">,</span> <span class="s2">&quot;pin&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="s2">&quot;fixed&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="s2">&quot;roller&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span> <span class="o">=</span> <span class="n">b</span><span class="o">.</span><span class="n">draw</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span>
<span class="go">Plot object containing:</span>
<span class="go">[0]: cartesian line: 25*SingularityFunction(x, 5, 0) - 25*SingularityFunction(x, 23, 0)</span>
<span class="go">+ SingularityFunction(x, 30, 1) - 20*SingularityFunction(x, 50, 0)</span>
<span class="go">- SingularityFunction(x, 50, 1) + 5 for x over (0.0, 50.0)</span>
<span class="go">[1]: cartesian line: 5 for x over (0.0, 50.0)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-1.png">png</a>, <a class="reference external" href="beam-1.hires.png">hires.png</a>, <a class="reference external" href="beam-1.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-1.png" class="plot-directive" src="../../../_images/beam-1.png" />
</figure>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.elastic_modulus">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">elastic_modulus</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.elastic_modulus" title="Permalink to this definition">¶</a></dt>
<dd><p>Young’s Modulus of the Beam.</p>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.ild_moment">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">ild_moment</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.ild_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the I.L.D. moment equation.</p>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.ild_reactions">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">ild_reactions</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.ild_reactions" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the I.L.D. reaction forces in a dictionary.</p>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.ild_shear">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">ild_shear</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.ild_shear" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the I.L.D. shear equation.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.join">
<span class="sig-name descname"><span class="pre">join</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">beam</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">via</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'fixed'</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L298-L359"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.join" title="Permalink to this definition">¶</a></dt>
<dd><p>This method joins two beams to make a new composite beam system.
Passed Beam class instance is attached to the right end of calling
object. This method can be used to form beams having Discontinuous
values of Elastic modulus or Second moment.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>beam</strong> : Beam class object</p>
<blockquote>
<div><p>The Beam object which would be connected to the right of calling
object.</p>
</div></blockquote>
<p><strong>via</strong> : String</p>
<blockquote>
<div><p>States the way two Beam object would get connected
- For axially fixed Beams, via=”fixed”
- For Beams connected via hinge, via=”hinge”</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a cantilever beam of length 4 meters. For first 2 meters
its moment of inertia is <span class="math notranslate nohighlight">\(1.5*I\)</span> and <span class="math notranslate nohighlight">\(I\)</span> for the other end.
A pointload of magnitude 4 N is applied from the top at its free end.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b1</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="mf">1.5</span><span class="o">*</span><span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b2</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">b1</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">b2</span><span class="p">,</span> <span class="s2">&quot;fixed&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_slope</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">80*SingularityFunction(x, 0, -2) - 20*SingularityFunction(x, 0, -1) + 20*SingularityFunction(x, 4, -1)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">slope</span><span class="p">()</span>
<span class="go">(-((-80*SingularityFunction(x, 0, 1) + 10*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 4, 2))/I + 120/I)/E + 80.0/(E*I))*SingularityFunction(x, 2, 0)</span>
<span class="go">- 0.666666666666667*(-80*SingularityFunction(x, 0, 1) + 10*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 4, 2))*SingularityFunction(x, 0, 0)/(E*I)</span>
<span class="go">+ 0.666666666666667*(-80*SingularityFunction(x, 0, 1) + 10*SingularityFunction(x, 0, 2) - 10*SingularityFunction(x, 4, 2))*SingularityFunction(x, 2, 0)/(E*I)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.length">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">length</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.length" title="Permalink to this definition">¶</a></dt>
<dd><p>Length of the Beam.</p>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.load">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">load</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.load" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a Singularity Function expression which represents
the load distribution curve of the Beam object.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 4 meters. A moment of magnitude 3 Nm is
applied in the clockwise direction at the starting point of the beam.
A point load of magnitude 4 N is applied from the top of the beam at
2 meters from the starting point and a parabolic ramp load of magnitude
2 N/m is applied below the beam starting from 3 meters away from the
starting point of the beam.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">-3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) - 2*SingularityFunction(x, 3, 2)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.max_bmoment">
<span class="sig-name descname"><span class="pre">max_bmoment</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L963-L1013"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.max_bmoment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns maximum Shear force and its coordinate
in the Beam object.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.max_deflection">
<span class="sig-name descname"><span class="pre">max_deflection</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1256-L1277"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.max_deflection" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns point of max deflection and its corresponding deflection value
in a Beam object.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.max_shear_force">
<span class="sig-name descname"><span class="pre">max_shear_force</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L877-L927"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.max_shear_force" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns maximum Shear force and its coordinate
in the Beam object.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.plot_bending_moment">
<span class="sig-name descname"><span class="pre">plot_bending_moment</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1408-L1464"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.plot_bending_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot for Bending moment present in the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 8 meters. A constant distributed load of 10 KN/m
is applied from half of the beam till the end. There are two simple supports
below the beam, one at the starting point and another at the ending point
of the beam. A pointload of magnitude 5 KN is also applied from top of the
beam, at a distance of 4 meters from the starting point.
Take E = 200 GPa and I = 400*(10**-6) meter**4.</p>
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">200</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">9</span><span class="p">),</span> <span class="mi">400</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**-</span><span class="mi">6</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">5000</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">10000</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_bending_moment</span><span class="p">()</span>
<span class="go">Plot object containing:</span>
<span class="go">[0]: cartesian line: 13750*SingularityFunction(x, 0, 1) - 5000*SingularityFunction(x, 2, 1)</span>
<span class="go">- 5000*SingularityFunction(x, 4, 2) + 31250*SingularityFunction(x, 8, 1)</span>
<span class="go">+ 5000*SingularityFunction(x, 8, 2) for x over (0.0, 8.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-2.png">png</a>, <a class="reference external" href="beam-2.hires.png">hires.png</a>, <a class="reference external" href="beam-2.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-2.png" class="plot-directive" src="../../../_images/beam-2.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.plot_deflection">
<span class="sig-name descname"><span class="pre">plot_deflection</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1524-L1582"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.plot_deflection" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot for deflection curve of the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 8 meters. A constant distributed load of 10 KN/m
is applied from half of the beam till the end. There are two simple supports
below the beam, one at the starting point and another at the ending point
of the beam. A pointload of magnitude 5 KN is also applied from top of the
beam, at a distance of 4 meters from the starting point.
Take E = 200 GPa and I = 400*(10**-6) meter**4.</p>
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">200</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">9</span><span class="p">),</span> <span class="mi">400</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**-</span><span class="mi">6</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">5000</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">10000</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_deflection</span><span class="p">()</span>
<span class="go">Plot object containing:</span>
<span class="go">[0]: cartesian line: 0.00138541666666667*x - 2.86458333333333e-5*SingularityFunction(x, 0, 3)</span>
<span class="go">+ 1.04166666666667e-5*SingularityFunction(x, 2, 3) + 5.20833333333333e-6*SingularityFunction(x, 4, 4)</span>
<span class="go">- 6.51041666666667e-5*SingularityFunction(x, 8, 3) - 5.20833333333333e-6*SingularityFunction(x, 8, 4)</span>
<span class="go">for x over (0.0, 8.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-3.png">png</a>, <a class="reference external" href="beam-3.hires.png">hires.png</a>, <a class="reference external" href="beam-3.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-3.png" class="plot-directive" src="../../../_images/beam-3.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.plot_ild_moment">
<span class="sig-name descname"><span class="pre">plot_ild_moment</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2006-L2070"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.plot_ild_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Plots the Influence Line Diagram for Moment under the effect
of a moving load. This function should be called after
calling solve_for_ild_moment().</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 12 meters. There are two simple supports
below the beam, one at the starting point and another at a distance
of 8 meters. Plot the I.L.D. for Moment at a distance
of 4 meters under the effect of a moving load of magnitude 1kN.</p>
<img alt="../../../_images/ildshear.png" src="../../../_images/ildshear.png" />
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R_0, R_8&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">12</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_reactions</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_moment</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">ild_moment</span>
<span class="go">Piecewise((-x/2, x &lt; 4), (x/2 - 4, x &gt; 4))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_ild_moment</span><span class="p">()</span>
<span class="go">Plot object containing:</span>
<span class="go">[0]: cartesian line: Piecewise((-x/2, x &lt; 4), (x/2 - 4, x &gt; 4)) for x over (0.0, 12.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-4.png">png</a>, <a class="reference external" href="beam-4.hires.png">hires.png</a>, <a class="reference external" href="beam-4.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-4.png" class="plot-directive" src="../../../_images/beam-4.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.plot_ild_reactions">
<span class="sig-name descname"><span class="pre">plot_ild_reactions</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1737-L1811"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.plot_ild_reactions" title="Permalink to this definition">¶</a></dt>
<dd><p>Plots the Influence Line Diagram of Reaction Forces
under the effect of a moving load. This function
should be called after calling solve_for_ild_reactions().</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 10 meters. A point load of magnitude 5KN
is also applied from top of the beam, at a distance of 4 meters
from the starting point. There are two simple supports below the
beam, located at the starting point and at a distance of 7 meters
from the starting point. Plot the I.L.D. equations for reactions
at both support points under the effect of a moving load
of magnitude 1kN.</p>
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R_0</span><span class="p">,</span> <span class="n">R_7</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R_0, R_7&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">7</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_reactions</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">R_0</span><span class="p">,</span><span class="n">R_7</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">ild_reactions</span>
<span class="go">{R_0: x/7 - 22/7, R_7: -x/7 - 20/7}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_ild_reactions</span><span class="p">()</span>
<span class="go">PlotGrid object containing:</span>
<span class="go">Plot[0]:Plot object containing:</span>
<span class="go">[0]: cartesian line: x/7 - 22/7 for x over (0.0, 10.0)</span>
<span class="go">Plot[1]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -x/7 - 20/7 for x over (0.0, 10.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-5.png">png</a>, <a class="reference external" href="beam-5.hires.png">hires.png</a>, <a class="reference external" href="beam-5.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-5.png" class="plot-directive" src="../../../_images/beam-5.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.plot_ild_shear">
<span class="sig-name descname"><span class="pre">plot_ild_shear</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1876-L1942"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.plot_ild_shear" title="Permalink to this definition">¶</a></dt>
<dd><p>Plots the Influence Line Diagram for Shear under the effect
of a moving load. This function should be called after
calling solve_for_ild_shear().</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 12 meters. There are two simple supports
below the beam, one at the starting point and another at a distance
of 8 meters. Plot the I.L.D. for Shear at a distance
of 4 meters under the effect of a moving load of magnitude 1kN.</p>
<img alt="../../../_images/ildshear.png" src="../../../_images/ildshear.png" />
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R_0, R_8&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">12</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_reactions</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_shear</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">ild_shear</span>
<span class="go">Piecewise((x/8, x &lt; 4), (x/8 - 1, x &gt; 4))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_ild_shear</span><span class="p">()</span>
<span class="go">Plot object containing:</span>
<span class="go">[0]: cartesian line: Piecewise((x/8, x &lt; 4), (x/8 - 1, x &gt; 4)) for x over (0.0, 12.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-6.png">png</a>, <a class="reference external" href="beam-6.hires.png">hires.png</a>, <a class="reference external" href="beam-6.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-6.png" class="plot-directive" src="../../../_images/beam-6.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.plot_loading_results">
<span class="sig-name descname"><span class="pre">plot_loading_results</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1585-L1650"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.plot_loading_results" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a subplot of Shear Force, Bending Moment,
Slope and Deflection of the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 8 meters. A constant distributed load of 10 KN/m
is applied from half of the beam till the end. There are two simple supports
below the beam, one at the starting point and another at the ending point
of the beam. A pointload of magnitude 5 KN is also applied from top of the
beam, at a distance of 4 meters from the starting point.
Take E = 200 GPa and I = 400*(10**-6) meter**4.</p>
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">200</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">9</span><span class="p">),</span> <span class="mi">400</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**-</span><span class="mi">6</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">5000</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">10000</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">axes</span> <span class="o">=</span> <span class="n">b</span><span class="o">.</span><span class="n">plot_loading_results</span><span class="p">()</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-7.png">png</a>, <a class="reference external" href="beam-7.hires.png">hires.png</a>, <a class="reference external" href="beam-7.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-7.png" class="plot-directive" src="../../../_images/beam-7.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.plot_shear_force">
<span class="sig-name descname"><span class="pre">plot_shear_force</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1350-L1406"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.plot_shear_force" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot for Shear force present in the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 8 meters. A constant distributed load of 10 KN/m
is applied from half of the beam till the end. There are two simple supports
below the beam, one at the starting point and another at the ending point
of the beam. A pointload of magnitude 5 KN is also applied from top of the
beam, at a distance of 4 meters from the starting point.
Take E = 200 GPa and I = 400*(10**-6) meter**4.</p>
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">200</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">9</span><span class="p">),</span> <span class="mi">400</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**-</span><span class="mi">6</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">5000</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">10000</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_shear_force</span><span class="p">()</span>
<span class="go">Plot object containing:</span>
<span class="go">[0]: cartesian line: 13750*SingularityFunction(x, 0, 0) - 5000*SingularityFunction(x, 2, 0)</span>
<span class="go">- 10000*SingularityFunction(x, 4, 1) + 31250*SingularityFunction(x, 8, 0)</span>
<span class="go">+ 10000*SingularityFunction(x, 8, 1) for x over (0.0, 8.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-8.png">png</a>, <a class="reference external" href="beam-8.hires.png">hires.png</a>, <a class="reference external" href="beam-8.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-8.png" class="plot-directive" src="../../../_images/beam-8.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.plot_shear_stress">
<span class="sig-name descname"><span class="pre">plot_shear_stress</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1286-L1347"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.plot_shear_stress" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot of shear stress present in the beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 8 meters and area of cross section 2 square
meters. A constant distributed load of 10 KN/m is applied from half of
the beam till the end. There are two simple supports below the beam,
one at the starting point and another at the ending point of the beam.
A pointload of magnitude 5 KN is also applied from top of the
beam, at a distance of 4 meters from the starting point.
Take E = 200 GPa and I = 400*(10**-6) meter**4.</p>
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">200</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">9</span><span class="p">),</span> <span class="mi">400</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**-</span><span class="mi">6</span><span class="p">),</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">5000</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">10000</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_shear_stress</span><span class="p">()</span>
<span class="go">Plot object containing:</span>
<span class="go">[0]: cartesian line: 6875*SingularityFunction(x, 0, 0) - 2500*SingularityFunction(x, 2, 0)</span>
<span class="go">- 5000*SingularityFunction(x, 4, 1) + 15625*SingularityFunction(x, 8, 0)</span>
<span class="go">+ 5000*SingularityFunction(x, 8, 1) for x over (0.0, 8.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-9.png">png</a>, <a class="reference external" href="beam-9.hires.png">hires.png</a>, <a class="reference external" href="beam-9.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-9.png" class="plot-directive" src="../../../_images/beam-9.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.plot_slope">
<span class="sig-name descname"><span class="pre">plot_slope</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1466-L1522"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.plot_slope" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot for slope of deflection curve of the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 8 meters. A constant distributed load of 10 KN/m
is applied from half of the beam till the end. There are two simple supports
below the beam, one at the starting point and another at the ending point
of the beam. A pointload of magnitude 5 KN is also applied from top of the
beam, at a distance of 4 meters from the starting point.
Take E = 200 GPa and I = 400*(10**-6) meter**4.</p>
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">200</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">9</span><span class="p">),</span> <span class="mi">400</span><span class="o">*</span><span class="p">(</span><span class="mi">10</span><span class="o">**-</span><span class="mi">6</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">5000</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">10000</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_slope</span><span class="p">()</span>
<span class="go">Plot object containing:</span>
<span class="go">[0]: cartesian line: -8.59375e-5*SingularityFunction(x, 0, 2) + 3.125e-5*SingularityFunction(x, 2, 2)</span>
<span class="go">+ 2.08333333333333e-5*SingularityFunction(x, 4, 3) - 0.0001953125*SingularityFunction(x, 8, 2)</span>
<span class="go">- 2.08333333333333e-5*SingularityFunction(x, 8, 3) + 0.00138541666666667 for x over (0.0, 8.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-10.png">png</a>, <a class="reference external" href="beam-10.hires.png">hires.png</a>, <a class="reference external" href="beam-10.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-10.png" class="plot-directive" src="../../../_images/beam-10.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.point_cflexure">
<span class="sig-name descname"><span class="pre">point_cflexure</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1015-L1055"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.point_cflexure" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a Set of point(s) with zero bending moment and
where bending moment curve of the beam object changes
its sign from negative to positive or vice versa.</p>
<p class="rubric">Examples</p>
<p>There is is 10 meter long overhanging beam. There are
two simple supports below the beam. One at the start
and another one at a distance of 6 meters from the start.
Point loads of magnitude 10KN and 20KN are applied at
2 meters and 4 meters from start respectively. A Uniformly
distribute load of magnitude of magnitude 3KN/m is also
applied on top starting from 6 meters away from starting
point till end.
Using the sign convention of upward forces and clockwise moment
being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">46</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">point_cflexure</span><span class="p">()</span>
<span class="go">[10/3]</span>
</pre></div>
</div>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.reaction_loads">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">reaction_loads</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.reaction_loads" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the reaction forces in a dictionary.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.remove_load">
<span class="sig-name descname"><span class="pre">remove_load</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">start</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">end</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L490-L552"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.remove_load" title="Permalink to this definition">¶</a></dt>
<dd><p>This method removes a particular load present on the beam object.
Returns a ValueError if the load passed as an argument is not
present on the beam.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>value</strong> : Sympifyable</p>
<blockquote>
<div><p>The magnitude of an applied load.</p>
</div></blockquote>
<p><strong>start</strong> : Sympifyable</p>
<blockquote>
<div><p>The starting point of the applied load. For point moments and
point forces this is the location of application.</p>
</div></blockquote>
<p><strong>order</strong> : Integer</p>
<blockquote>
<div><p>The order of the applied load.
- For moments, order= -2
- For point loads, order=-1
- For constant distributed load, order=0
- For ramp loads, order=1
- For parabolic ramp loads, order=2
- … so on.</p>
</div></blockquote>
<p><strong>end</strong> : Sympifyable, optional</p>
<blockquote>
<div><p>An optional argument that can be used if the load has an end point
within the length of the beam.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 4 meters. A moment of magnitude 3 Nm is
applied in the clockwise direction at the starting point of the beam.
A pointload of magnitude 4 N is applied from the top of the beam at
2 meters from the starting point and a parabolic ramp load of magnitude
2 N/m is applied below the beam starting from 2 meters to 3 meters
away from the starting point of the beam.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">-3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1) - 2*SingularityFunction(x, 2, 2) + 2*SingularityFunction(x, 3, 0) + 4*SingularityFunction(x, 3, 1) + 2*SingularityFunction(x, 3, 2)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">remove_load</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">end</span> <span class="o">=</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">-3*SingularityFunction(x, 0, -2) + 4*SingularityFunction(x, 2, -1)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.second_moment">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">second_moment</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.second_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Second moment of area of the Beam.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.shear_force">
<span class="sig-name descname"><span class="pre">shear_force</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L843-L875"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.shear_force" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a Singularity Function expression which represents
the shear force curve of the Beam object.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 30 meters. A moment of magnitude 120 Nm is
applied in the clockwise direction at the end of the beam. A pointload
of magnitude 8 N is applied from the top of the beam at the starting
point. There are two simple supports below the beam. One at the end
and another one at a distance of 10 meters from the start. The
deflection is restricted at both the supports.</p>
<p>Using the sign convention of upward forces and clockwise moment
being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">120</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">shear_force</span><span class="p">()</span>
<span class="go">8*SingularityFunction(x, 0, 0) - 6*SingularityFunction(x, 10, 0) - 120*SingularityFunction(x, 30, -1) - 2*SingularityFunction(x, 30, 0)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.shear_stress">
<span class="sig-name descname"><span class="pre">shear_stress</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1279-L1284"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.shear_stress" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns an expression representing the Shear Stress
curve of the Beam object.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.slope">
<span class="sig-name descname"><span class="pre">slope</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1057-L1123"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.slope" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a Singularity Function expression which represents
the slope the elastic curve of the Beam object.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 30 meters. A moment of magnitude 120 Nm is
applied in the clockwise direction at the end of the beam. A pointload
of magnitude 8 N is applied from the top of the beam at the starting
point. There are two simple supports below the beam. One at the end
and another one at a distance of 10 meters from the start. The
deflection is restricted at both the supports.</p>
<p>Using the sign convention of upward forces and clockwise moment
being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">120</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">slope</span><span class="p">()</span>
<span class="go">(-4*SingularityFunction(x, 0, 2) + 3*SingularityFunction(x, 10, 2)</span>
<span class="go">    + 120*SingularityFunction(x, 30, 1) + SingularityFunction(x, 30, 2) + 4000/3)/(E*I)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.solve_for_ild_moment">
<span class="sig-name descname"><span class="pre">solve_for_ild_moment</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">distance</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">reactions</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1944-L2004"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.solve_for_ild_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Determines the Influence Line Diagram equations for moment at a
specified point under the effect of a moving load.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>distance</strong> : Integer</p>
<blockquote>
<div><p>Distance of the point from the start of the beam
for which equations are to be determined</p>
</div></blockquote>
<p><strong>value</strong> : Integer</p>
<blockquote>
<div><p>Magnitude of moving load</p>
</div></blockquote>
<p><strong>reactions :</strong></p>
<blockquote>
<div><p>The reaction forces applied on the beam.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 12 meters. There are two simple supports
below the beam, one at the starting point and another at a distance
of 8 meters. Calculate the I.L.D. equations for Moment at a distance
of 4 meters under the effect of a moving load of magnitude 1kN.</p>
<img alt="../../../_images/ildshear.png" src="../../../_images/ildshear.png" />
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R_0, R_8&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">12</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_reactions</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_moment</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">ild_moment</span>
<span class="go">Piecewise((-x/2, x &lt; 4), (x/2 - 4, x &gt; 4))</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.solve_for_ild_reactions">
<span class="sig-name descname"><span class="pre">solve_for_ild_reactions</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">reactions</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1666-L1735"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.solve_for_ild_reactions" title="Permalink to this definition">¶</a></dt>
<dd><p>Determines the Influence Line Diagram equations for reaction
forces under the effect of a moving load.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>value</strong> : Integer</p>
<blockquote>
<div><p>Magnitude of moving load</p>
</div></blockquote>
<p><strong>reactions :</strong></p>
<blockquote>
<div><p>The reaction forces applied on the beam.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 10 meters. There are two simple supports
below the beam, one at the starting point and another at the ending
point of the beam. Calculate the I.L.D. equations for reaction forces
under the effect of a moving load of magnitude 1kN.</p>
<img alt="../../../_images/ildreaction.png" src="../../../_images/ildreaction.png" />
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R_0</span><span class="p">,</span> <span class="n">R_10</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R_0, R_10&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_reactions</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">R_0</span><span class="p">,</span><span class="n">R_10</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">ild_reactions</span>
<span class="go">{R_0: x/10 - 1, R_10: -x/10}</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.solve_for_ild_shear">
<span class="sig-name descname"><span class="pre">solve_for_ild_shear</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">distance</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">reactions</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L1813-L1874"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.solve_for_ild_shear" title="Permalink to this definition">¶</a></dt>
<dd><p>Determines the Influence Line Diagram equations for shear at a
specified point under the effect of a moving load.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>distance</strong> : Integer</p>
<blockquote>
<div><p>Distance of the point from the start of the beam
for which equations are to be determined</p>
</div></blockquote>
<p><strong>value</strong> : Integer</p>
<blockquote>
<div><p>Magnitude of moving load</p>
</div></blockquote>
<p><strong>reactions :</strong></p>
<blockquote>
<div><p>The reaction forces applied on the beam.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 12 meters. There are two simple supports
below the beam, one at the starting point and another at a distance
of 8 meters. Calculate the I.L.D. equations for Shear at a distance
of 4 meters under the effect of a moving load of magnitude 1kN.</p>
<img alt="../../../_images/ildshear.png" src="../../../_images/ildshear.png" />
<p>Using the sign convention of downwards forces being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R_0, R_8&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">12</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_support</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="s1">&#39;roller&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_reactions</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_ild_shear</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">R_0</span><span class="p">,</span> <span class="n">R_8</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">ild_shear</span>
<span class="go">Piecewise((x/8, x &lt; 4), (x/8 - 1, x &gt; 4))</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.solve_for_reaction_loads">
<span class="sig-name descname"><span class="pre">solve_for_reaction_loads</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">reactions</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L776-L841"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.solve_for_reaction_loads" title="Permalink to this definition">¶</a></dt>
<dd><p>Solves for the reaction forces.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 30 meters. A moment of magnitude 120 Nm is
applied in the clockwise direction at the end of the beam. A pointload
of magnitude 8 N is applied from the top of the beam at the starting
point. There are two simple supports below the beam. One at the end
and another one at a distance of 10 meters from the start. The
deflection is restricted at both the supports.</p>
<p>Using the sign convention of upward forces and clockwise moment
being positive.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="o">-</span><span class="mi">8</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>  <span class="c1"># Reaction force at x = 10</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>  <span class="c1"># Reaction force at x = 30</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">120</span><span class="p">,</span> <span class="mi">30</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">R1*SingularityFunction(x, 10, -1) + R2*SingularityFunction(x, 30, -1)</span>
<span class="go">    - 8*SingularityFunction(x, 0, -1) + 120*SingularityFunction(x, 30, -2)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">reaction_loads</span>
<span class="go">{R1: 6, R2: 2}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">load</span>
<span class="go">-8*SingularityFunction(x, 0, -1) + 6*SingularityFunction(x, 10, -1)</span>
<span class="go">    + 120*SingularityFunction(x, 30, -2) + 2*SingularityFunction(x, 30, -1)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam.variable">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">variable</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam.variable" title="Permalink to this definition">¶</a></dt>
<dd><p>A symbol that can be used as a variable along the length of the beam
while representing load distribution, shear force curve, bending
moment, slope curve and the deflection curve. By default, it is set
to <code class="docutils literal notranslate"><span class="pre">Symbol('x')</span></code>, but this property is mutable.</p>
<p class="rubric">Examples</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;E, I, A&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;x, y, z&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">variable</span>
<span class="go">x</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">variable</span> <span class="o">=</span> <span class="n">y</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">variable</span>
<span class="go">y</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">z</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">variable</span>
<span class="go">z</span>
</pre></div>
</div>
</dd></dl>

</dd></dl>

<dl class="py class">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D">
<em class="property"><span class="pre">class</span> </em><span class="sig-prename descclassname"><span class="pre">sympy.physics.continuum_mechanics.beam.</span></span><span class="sig-name descname"><span class="pre">Beam3D</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">length</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">elastic_modulus</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">shear_modulus</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">second_moment</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">area</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">variable</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">x</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2303-L3567"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D" title="Permalink to this definition">¶</a></dt>
<dd><p>This class handles loads applied in any direction of a 3D space along
with unequal values of Second moment along different axes.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>While solving a beam bending problem, a user should choose its
own sign convention and should stick to it. The results will
automatically follow the chosen sign convention.
This class assumes that any kind of distributed load/moment is
applied through out the span of a beam.</p>
</div>
<p class="rubric">Examples</p>
<p>There is a beam of l meters long. A constant distributed load of magnitude q
is applied along y-axis from start till the end of beam. A constant distributed
moment of magnitude m is also applied along z-axis from start till the end of beam.
Beam is fixed at both of its end. So, deflection of the beam at the both ends
is restricted.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span><span class="p">,</span> <span class="n">simplify</span><span class="p">,</span> <span class="n">collect</span><span class="p">,</span> <span class="n">factor</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">,</span> <span class="n">q</span><span class="p">,</span> <span class="n">m</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;x, q, m&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">q</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_moment_load</span><span class="p">(</span><span class="n">m</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">shear_force</span><span class="p">()</span>
<span class="go">[0, -q*x, 0]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bending_moment</span><span class="p">()</span>
<span class="go">[0, 0, -m*x + q*x**2/2]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_slope</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_slope_deflection</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">factor</span><span class="p">(</span><span class="n">b</span><span class="o">.</span><span class="n">slope</span><span class="p">())</span>
<span class="go">[0, 0, x*(-l + x)*(-A*G*l**3*q + 2*A*G*l**2*q*x - 12*E*I*l*q</span>
<span class="go">    - 72*E*I*m + 24*E*I*q*x)/(12*E*I*(A*G*l**2 + 12*E*I))]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">dx</span><span class="p">,</span> <span class="n">dy</span><span class="p">,</span> <span class="n">dz</span> <span class="o">=</span> <span class="n">b</span><span class="o">.</span><span class="n">deflection</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">dy</span> <span class="o">=</span> <span class="n">collect</span><span class="p">(</span><span class="n">simplify</span><span class="p">(</span><span class="n">dy</span><span class="p">),</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">dx</span> <span class="o">==</span> <span class="n">dz</span> <span class="o">==</span> <span class="mi">0</span>
<span class="go">True</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">dy</span> <span class="o">==</span> <span class="p">(</span><span class="n">x</span><span class="o">*</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">E</span><span class="o">*</span><span class="n">I</span><span class="o">*</span><span class="n">l</span><span class="o">*</span><span class="p">(</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">**</span><span class="mi">2</span><span class="o">*</span><span class="n">q</span> <span class="o">-</span> <span class="mi">2</span><span class="o">*</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">*</span><span class="n">m</span> <span class="o">+</span> <span class="mi">12</span><span class="o">*</span><span class="n">E</span><span class="o">*</span><span class="n">I</span><span class="o">*</span><span class="n">q</span><span class="p">)</span>
<span class="gp">... </span><span class="o">+</span> <span class="n">x</span><span class="o">*</span><span class="p">(</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">*</span><span class="p">(</span><span class="mi">3</span><span class="o">*</span><span class="n">l</span><span class="o">*</span><span class="p">(</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">**</span><span class="mi">2</span><span class="o">*</span><span class="n">q</span> <span class="o">-</span> <span class="mi">2</span><span class="o">*</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">*</span><span class="n">m</span> <span class="o">+</span> <span class="mi">12</span><span class="o">*</span><span class="n">E</span><span class="o">*</span><span class="n">I</span><span class="o">*</span><span class="n">q</span><span class="p">)</span> <span class="o">+</span> <span class="n">x</span><span class="o">*</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="o">*</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">**</span><span class="mi">2</span><span class="o">*</span><span class="n">q</span> <span class="o">+</span> <span class="mi">4</span><span class="o">*</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">*</span><span class="n">m</span> <span class="o">-</span> <span class="mi">24</span><span class="o">*</span><span class="n">E</span><span class="o">*</span><span class="n">I</span><span class="o">*</span><span class="n">q</span><span class="p">))</span>
<span class="gp">... </span><span class="o">+</span> <span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="p">(</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="mi">12</span><span class="o">*</span><span class="n">E</span><span class="o">*</span><span class="n">I</span><span class="p">)</span><span class="o">*</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="o">*</span><span class="n">l</span><span class="o">**</span><span class="mi">2</span><span class="o">*</span><span class="n">q</span> <span class="o">+</span> <span class="mi">6</span><span class="o">*</span><span class="n">l</span><span class="o">*</span><span class="n">m</span> <span class="o">-</span> <span class="mi">4</span><span class="o">*</span><span class="n">m</span><span class="o">*</span><span class="n">x</span> <span class="o">+</span> <span class="n">q</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">... </span><span class="o">-</span> <span class="mi">12</span><span class="o">*</span><span class="n">E</span><span class="o">*</span><span class="n">I</span><span class="o">*</span><span class="n">q</span><span class="o">*</span><span class="p">(</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="mi">12</span><span class="o">*</span><span class="n">E</span><span class="o">*</span><span class="n">I</span><span class="p">)))</span><span class="o">/</span><span class="p">(</span><span class="mi">24</span><span class="o">*</span><span class="n">A</span><span class="o">*</span><span class="n">E</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">I</span><span class="o">*</span><span class="p">(</span><span class="n">A</span><span class="o">*</span><span class="n">G</span><span class="o">*</span><span class="n">l</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="mi">12</span><span class="o">*</span><span class="n">E</span><span class="o">*</span><span class="n">I</span><span class="p">)))</span>
<span class="go">True</span>
</pre></div>
</div>
<p class="rubric">References</p>
<dl class="citation">
<dt class="label" id="r602"><span class="brackets"><a class="fn-backref" href="#id1">R602</a></span></dt>
<dd><p><a class="reference external" href="http://homes.civil.aau.dk/jc/FemteSemester/Beams3D.pdf">http://homes.civil.aau.dk/jc/FemteSemester/Beams3D.pdf</a></p>
</dd>
</dl>
<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.apply_load">
<span class="sig-name descname"><span class="pre">apply_load</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">start</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dir</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'y'</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2491-L2527"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.apply_load" title="Permalink to this definition">¶</a></dt>
<dd><p>This method adds up the force load to a particular beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>value</strong> : Sympifyable</p>
<blockquote>
<div><p>The magnitude of an applied load.</p>
</div></blockquote>
<p><strong>dir</strong> : String</p>
<blockquote>
<div><p>Axis along which load is applied.</p>
</div></blockquote>
<p><strong>order</strong> : Integer</p>
<blockquote>
<div><p>The order of the applied load.
- For point loads, order=-1
- For constant distributed load, order=0
- For ramp loads, order=1
- For parabolic ramp loads, order=2
- … so on.</p>
</div></blockquote>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.apply_moment_load">
<span class="sig-name descname"><span class="pre">apply_moment_load</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">start</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">order</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">dir</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'y'</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2529-L2563"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.apply_moment_load" title="Permalink to this definition">¶</a></dt>
<dd><p>This method adds up the moment loads to a particular beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>value</strong> : Sympifyable</p>
<blockquote>
<div><p>The magnitude of an applied moment.</p>
</div></blockquote>
<p><strong>dir</strong> : String</p>
<blockquote>
<div><p>Axis along which moment is applied.</p>
</div></blockquote>
<p><strong>order</strong> : Integer</p>
<blockquote>
<div><p>The order of the applied load.
- For point moments, order=-2
- For constant distributed moment, order=-1
- For ramp moments, order=0
- For parabolic ramp moments, order=1
- … so on.</p>
</div></blockquote>
</dd>
</dl>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.area">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">area</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.area" title="Permalink to this definition">¶</a></dt>
<dd><p>Cross-sectional area of the Beam.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.axial_force">
<span class="sig-name descname"><span class="pre">axial_force</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2634-L2638"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.axial_force" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns expression of Axial shear force present inside the Beam object.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.axial_stress">
<span class="sig-name descname"><span class="pre">axial_stress</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2647-L2651"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.axial_stress" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns expression of Axial stress present inside the Beam object.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.bending_moment">
<span class="sig-name descname"><span class="pre">bending_moment</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2653-L2663"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.bending_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a list of three expressions which represents the bending moment
curve of the Beam object along all three axes.</p>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.boundary_conditions">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">boundary_conditions</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.boundary_conditions" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a dictionary of boundary conditions applied on the beam.
The dictionary has two keywords namely slope and deflection.
The value of each keyword is a list of tuple, where each tuple
contains location and value of a boundary condition in the format
(location, value). Further each value is a list corresponding to
slope or deflection(s) values along three axes at that location.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 4 meters. The slope at 0 should be 4 along
the x-axis and 0 along others. At the other end of beam, deflection
along all the three axes should be zero.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_slope</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">))]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">4</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">boundary_conditions</span>
<span class="go">{&#39;deflection&#39;: [(4, [0, 0, 0])], &#39;slope&#39;: [(0, (4, 0, 0))]}</span>
</pre></div>
</div>
<p>Here the deflection of the beam should be <code class="docutils literal notranslate"><span class="pre">0</span></code> along all the three axes at <code class="docutils literal notranslate"><span class="pre">4</span></code>.
Similarly, the slope of the beam should be <code class="docutils literal notranslate"><span class="pre">4</span></code> along x-axis and <code class="docutils literal notranslate"><span class="pre">0</span></code>
along y and z axis at <code class="docutils literal notranslate"><span class="pre">0</span></code>.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.deflection">
<span class="sig-name descname"><span class="pre">deflection</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2747-L2752"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.deflection" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a three element list representing deflection curve along all
the three axes.</p>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.load_vector">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">load_vector</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.load_vector" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a three element list representing the load vector.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.max_bending_moment">
<span class="sig-name descname"><span class="pre">max_bending_moment</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L3448-L3487"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.max_bending_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns point of max bending moment and its corresponding bending moment value
along all directions in a Beam object as a list.
solve_for_reaction_loads() must be called before using this function.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters. It it supported by rollers
at of its end. A linear load having slope equal to 12 is applied
along y-axis. A constant distributed load of magnitude 15 N is
applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="mi">40</span><span class="p">,</span> <span class="mi">21</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">25</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">max_bending_moment</span><span class="p">()</span>
<span class="go">[(0, 0), (20, 3000), (20, 16000)]</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.max_bmoment">
<span class="sig-name descname"><span class="pre">max_bmoment</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L3448-L3487"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.max_bmoment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns point of max bending moment and its corresponding bending moment value
along all directions in a Beam object as a list.
solve_for_reaction_loads() must be called before using this function.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters. It it supported by rollers
at of its end. A linear load having slope equal to 12 is applied
along y-axis. A constant distributed load of magnitude 15 N is
applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="mi">40</span><span class="p">,</span> <span class="mi">21</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">25</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">max_bending_moment</span><span class="p">()</span>
<span class="go">[(0, 0), (20, 3000), (20, 16000)]</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.max_deflection">
<span class="sig-name descname"><span class="pre">max_deflection</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L3526-L3567"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.max_deflection" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns point of max deflection and its corresponding deflection value
along all directions in a Beam object as a list.
solve_for_reaction_loads() and solve_slope_deflection() must be called
before using this function.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters. It it supported by rollers
at of its end. A linear load having slope equal to 12 is applied
along y-axis. A constant distributed load of magnitude 15 N is
applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="mi">40</span><span class="p">,</span> <span class="mi">21</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">25</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_slope_deflection</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">max_deflection</span><span class="p">()</span>
<span class="go">[(0, 0), (10, 495/14), (-10 + 10*sqrt(10793)/43, (10 - 10*sqrt(10793)/43)**3/160 - 20/7 + (10 - 10*sqrt(10793)/43)**4/6400 + 20*sqrt(10793)/301 + 27*(10 - 10*sqrt(10793)/43)**2/560)]</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.max_shear_force">
<span class="sig-name descname"><span class="pre">max_shear_force</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L3371-L3410"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.max_shear_force" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns point of max shear force and its corresponding shear value
along all directions in a Beam object as a list.
solve_for_reaction_loads() must be called before using this function.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters. It it supported by rollers
at of its end. A linear load having slope equal to 12 is applied
along y-axis. A constant distributed load of magnitude 15 N is
applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="mi">40</span><span class="p">,</span> <span class="mi">21</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">25</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">max_shear_force</span><span class="p">()</span>
<span class="go">[(0, 0), (20, 2400), (20, 300)]</span>
</pre></div>
</div>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.moment_load_vector">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">moment_load_vector</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.moment_load_vector" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a three element list representing moment loads on Beam.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.plot_bending_moment">
<span class="sig-name descname"><span class="pre">plot_bending_moment</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dir</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'all'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2886-L2956"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.plot_bending_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot for bending moment along all three directions
present in the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>dir</strong> : string (default</p>
<blockquote>
<div><p>Direction along which bending moment plot is required.
If no direction is specified, all plots are displayed.</p>
</div></blockquote>
<p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters. It it supported by rollers
at of its end. A linear load having slope equal to 12 is applied
along y-axis. A constant distributed load of magnitude 15 N is
applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_bending_moment</span><span class="p">()</span>
<span class="go">PlotGrid object containing:</span>
<span class="go">Plot[0]:Plot object containing:</span>
<span class="go">[0]: cartesian line: 0 for x over (0.0, 20.0)</span>
<span class="go">Plot[1]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -15*x**2/2 for x over (0.0, 20.0)</span>
<span class="go">Plot[2]:Plot object containing:</span>
<span class="go">[0]: cartesian line: 2*x**3 for x over (0.0, 20.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-18.png">png</a>, <a class="reference external" href="beam-18.hires.png">hires.png</a>, <a class="reference external" href="beam-18.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-18.png" class="plot-directive" src="../../../_images/beam-18.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.plot_deflection">
<span class="sig-name descname"><span class="pre">plot_deflection</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dir</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'all'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L3092-L3164"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.plot_deflection" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot for Deflection along all three directions
present in the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>dir</strong> : string (default</p>
<blockquote>
<div><p>Direction along which deflection plot is required.
If no direction is specified, all plots are displayed.</p>
</div></blockquote>
<p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as keys and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters. It it supported by rollers
at of its end. A linear load having slope equal to 12 is applied
along y-axis. A constant distributed load of magnitude 15 N is
applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="mi">40</span><span class="p">,</span> <span class="mi">21</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">25</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_slope_deflection</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_deflection</span><span class="p">()</span>
<span class="go">PlotGrid object containing:</span>
<span class="go">Plot[0]:Plot object containing:</span>
<span class="go">[0]: cartesian line: 0 for x over (0.0, 20.0)</span>
<span class="go">Plot[1]:Plot object containing:</span>
<span class="go">[0]: cartesian line: x**5/40000 - 4013*x**3/90300 + 26*x**2/43 + 1520*x/903 for x over (0.0, 20.0)</span>
<span class="go">Plot[2]:Plot object containing:</span>
<span class="go">[0]: cartesian line: x**4/6400 - x**3/160 + 27*x**2/560 + 2*x/7 for x over (0.0, 20.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-19.png">png</a>, <a class="reference external" href="beam-19.hires.png">hires.png</a>, <a class="reference external" href="beam-19.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-19.png" class="plot-directive" src="../../../_images/beam-19.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.plot_loading_results">
<span class="sig-name descname"><span class="pre">plot_loading_results</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dir</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'x'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L3166-L3232"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.plot_loading_results" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a subplot of Shear Force, Bending Moment,
Slope and Deflection of the Beam object along the direction specified.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>dir</strong> : string (default</p>
<blockquote>
<div><p>Direction along which plots are required.
If no direction is specified, plots along x-axis are displayed.</p>
</div></blockquote>
<p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters. It it supported by rollers
at of its end. A linear load having slope equal to 12 is applied
along y-axis. A constant distributed load of magnitude 15 N is
applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">subs</span> <span class="o">=</span> <span class="p">{</span><span class="n">E</span><span class="p">:</span><span class="mi">40</span><span class="p">,</span> <span class="n">G</span><span class="p">:</span><span class="mi">21</span><span class="p">,</span> <span class="n">I</span><span class="p">:</span><span class="mi">100</span><span class="p">,</span> <span class="n">A</span><span class="p">:</span><span class="mi">25</span><span class="p">}</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_slope_deflection</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_loading_results</span><span class="p">(</span><span class="s1">&#39;y&#39;</span><span class="p">,</span><span class="n">subs</span><span class="p">)</span>
<span class="go">PlotGrid object containing:</span>
<span class="go">Plot[0]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -6*x**2 for x over (0.0, 20.0)</span>
<span class="go">Plot[1]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -15*x**2/2 for x over (0.0, 20.0)</span>
<span class="go">Plot[2]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -x**3/1600 + 3*x**2/160 - x/8 for x over (0.0, 20.0)</span>
<span class="go">Plot[3]:Plot object containing:</span>
<span class="go">[0]: cartesian line: x**5/40000 - 4013*x**3/90300 + 26*x**2/43 + 1520*x/903 for x over (0.0, 20.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-20.png">png</a>, <a class="reference external" href="beam-20.hires.png">hires.png</a>, <a class="reference external" href="beam-20.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-20.png" class="plot-directive" src="../../../_images/beam-20.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.plot_shear_force">
<span class="sig-name descname"><span class="pre">plot_shear_force</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dir</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'all'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2784-L2854"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.plot_shear_force" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot for Shear force along all three directions
present in the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>dir</strong> : string (default</p>
<blockquote>
<div><p>Direction along which shear force plot is required.
If no direction is specified, all plots are displayed.</p>
</div></blockquote>
<p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters. It it supported by rollers
at of its end. A linear load having slope equal to 12 is applied
along y-axis. A constant distributed load of magnitude 15 N is
applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_shear_force</span><span class="p">()</span>
<span class="go">PlotGrid object containing:</span>
<span class="go">Plot[0]:Plot object containing:</span>
<span class="go">[0]: cartesian line: 0 for x over (0.0, 20.0)</span>
<span class="go">Plot[1]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -6*x**2 for x over (0.0, 20.0)</span>
<span class="go">Plot[2]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -15*x for x over (0.0, 20.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-21.png">png</a>, <a class="reference external" href="beam-21.hires.png">hires.png</a>, <a class="reference external" href="beam-21.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-21.png" class="plot-directive" src="../../../_images/beam-21.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.plot_shear_stress">
<span class="sig-name descname"><span class="pre">plot_shear_stress</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dir</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'all'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L3264-L3334"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.plot_shear_stress" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot for Shear Stress along all three directions
present in the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>dir</strong> : string (default</p>
<blockquote>
<div><p>Direction along which shear stress plot is required.
If no direction is specified, all plots are displayed.</p>
</div></blockquote>
<p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as key and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters and area of cross section 2 square
meters. It it supported by rollers at of its end. A linear load having
slope equal to 12 is applied along y-axis. A constant distributed load
of magnitude 15 N is applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_shear_stress</span><span class="p">()</span>
<span class="go">PlotGrid object containing:</span>
<span class="go">Plot[0]:Plot object containing:</span>
<span class="go">[0]: cartesian line: 0 for x over (0.0, 20.0)</span>
<span class="go">Plot[1]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -3*x**2 for x over (0.0, 20.0)</span>
<span class="go">Plot[2]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -15*x/2 for x over (0.0, 20.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-22.png">png</a>, <a class="reference external" href="beam-22.hires.png">hires.png</a>, <a class="reference external" href="beam-22.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-22.png" class="plot-directive" src="../../../_images/beam-22.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.plot_slope">
<span class="sig-name descname"><span class="pre">plot_slope</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dir</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'all'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">subs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2989-L3060"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.plot_slope" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a plot for Slope along all three directions
present in the Beam object.</p>
<dl class="field-list">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>dir</strong> : string (default</p>
<blockquote>
<div><p>Direction along which Slope plot is required.
If no direction is specified, all plots are displayed.</p>
</div></blockquote>
<p><strong>subs</strong> : dictionary</p>
<blockquote>
<div><p>Python dictionary containing Symbols as keys and their
corresponding values.</p>
</div></blockquote>
</dd>
</dl>
<p class="rubric">Examples</p>
<p>There is a beam of length 20 meters. It it supported by rollers
at of its end. A linear load having slope equal to 12 is applied
along y-axis. A constant distributed load of magnitude 15 N is
applied from start till its end along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="mi">40</span><span class="p">,</span> <span class="mi">21</span><span class="p">,</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">25</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">15</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">12</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">20</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">20</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_slope_deflection</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">plot_slope</span><span class="p">()</span>
<span class="go">PlotGrid object containing:</span>
<span class="go">Plot[0]:Plot object containing:</span>
<span class="go">[0]: cartesian line: 0 for x over (0.0, 20.0)</span>
<span class="go">Plot[1]:Plot object containing:</span>
<span class="go">[0]: cartesian line: -x**3/1600 + 3*x**2/160 - x/8 for x over (0.0, 20.0)</span>
<span class="go">Plot[2]:Plot object containing:</span>
<span class="go">[0]: cartesian line: x**4/8000 - 19*x**2/172 + 52*x/43 for x over (0.0, 20.0)</span>
</pre></div>
</div>
<p>(<a class="reference external" href="beam-23.png">png</a>, <a class="reference external" href="beam-23.hires.png">hires.png</a>, <a class="reference external" href="beam-23.pdf">pdf</a>)</p>
<figure class="align-default">
<img alt="../../../_images/beam-23.png" class="plot-directive" src="../../../_images/beam-23.png" />
</figure>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.polar_moment">
<span class="sig-name descname"><span class="pre">polar_moment</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2468-L2489"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.polar_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the polar moment of area of the beam
about the X axis with respect to the centroid.</p>
<p class="rubric">Examples</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">polar_moment</span><span class="p">()</span>
<span class="go">2*I</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">I1</span> <span class="o">=</span> <span class="p">[</span><span class="mi">9</span><span class="p">,</span> <span class="mi">15</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I1</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">polar_moment</span><span class="p">()</span>
<span class="go">24</span>
</pre></div>
</div>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.second_moment">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">second_moment</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.second_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Second moment of area of the Beam.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.shear_force">
<span class="sig-name descname"><span class="pre">shear_force</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2625-L2632"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.shear_force" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a list of three expressions which represents the shear force
curve of the Beam object along all three axes.</p>
</dd></dl>

<dl class="py property">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.shear_modulus">
<em class="property"><span class="pre">property</span> </em><span class="sig-name descname"><span class="pre">shear_modulus</span></span><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.shear_modulus" title="Permalink to this definition">¶</a></dt>
<dd><p>Young’s Modulus of the Beam.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.shear_stress">
<span class="sig-name descname"><span class="pre">shear_stress</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2640-L2645"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.shear_stress" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a list of three expressions which represents the shear stress
curve of the Beam object along all three axes.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.slope">
<span class="sig-name descname"><span class="pre">slope</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2740-L2745"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.slope" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a three element list representing slope of deflection curve
along all the three axes.</p>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.solve_for_reaction_loads">
<span class="sig-name descname"><span class="pre">solve_for_reaction_loads</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">reaction</span></span></em><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2577-L2623"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.solve_for_reaction_loads" title="Permalink to this definition">¶</a></dt>
<dd><p>Solves for the reaction forces.</p>
<p class="rubric">Examples</p>
<p>There is a beam of length 30 meters. It it supported by rollers at
of its end. A constant distributed load of magnitude 8 N is applied
from start till its end along y-axis. Another linear load having
slope equal to 9 is applied along z-axis.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.continuum_mechanics.beam</span> <span class="kn">import</span> <span class="n">Beam3D</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">symbols</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;l, E, G, I, A, x&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">Beam3D</span><span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="mi">9</span><span class="o">*</span><span class="n">x</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">bc_deflection</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">(</span><span class="mi">30</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">])]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;R1, R2, R3, R4&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R2</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">30</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;y&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R3</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">apply_load</span><span class="p">(</span><span class="n">R4</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">30</span><span class="p">,</span> <span class="n">order</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">dir</span><span class="o">=</span><span class="s2">&quot;z&quot;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">solve_for_reaction_loads</span><span class="p">(</span><span class="n">R1</span><span class="p">,</span> <span class="n">R2</span><span class="p">,</span> <span class="n">R3</span><span class="p">,</span> <span class="n">R4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="o">.</span><span class="n">reaction_loads</span>
<span class="go">{R1: -120, R2: -120, R3: -1350, R4: -2700}</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt class="sig sig-object py" id="sympy.physics.continuum_mechanics.beam.Beam3D.torsional_moment">
<span class="sig-name descname"><span class="pre">torsional_moment</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference external" href="https://github.com/sympy/sympy/blob/00d6469eafdd4aac346a0b598184c15f2560dbe5/sympy/physics/continuum_mechanics/beam.py#L2665-L2669"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#sympy.physics.continuum_mechanics.beam.Beam3D.torsional_moment" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns expression of Torsional moment present inside the Beam object.</p>
</dd></dl>

</dd></dl>

</section>
</section>


            <div class="clearer"></div>
          </div>
        </div>
      </div>
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper">
            <p class="logo"><a href="../../../index.html">
              <img class="logo" src="../../../_static/sympylogo.png" alt="Logo"/>
            </a></p>
  <h3><a href="../../../index.html">Table of Contents</a></h3>
  <ul>
<li><a class="reference internal" href="#">Beam (Docstrings)</a><ul>
<li><a class="reference internal" href="#module-sympy.physics.continuum_mechanics.beam">Beam</a></li>
</ul>
</li>
</ul>

  <h4>Previous topic</h4>
  <p class="topless"><a href="index.html"
                        title="previous chapter">Continuum Mechanics</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="beam_problems.html"
                        title="next chapter">Solving Beam Bending Problems using Singularity Functions</a></p>
  <div role="note" aria-label="source link">
    <h3>This Page</h3>
    <ul class="this-page-menu">
      <li><a href="../../../_sources/modules/physics/continuum_mechanics/beam.rst.txt"
            rel="nofollow">Show Source</a></li>
    </ul>
   </div>
<div id="searchbox" style="display: none" role="search">
  <h3 id="searchlabel">Quick search</h3>
    <div class="searchformwrapper">
    <form class="search" action="https://docs.sympy.org/latest/search.html" method="get">
      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
      <input type="submit" value="Go" />
    </form>
    </div>
</div>
<script>$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../../../genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="../../../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="beam_problems.html" title="Solving Beam Bending Problems using Singularity Functions"
             >next</a> |</li>
        <li class="right" >
          <a href="index.html" title="Continuum Mechanics"
             >previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="../../../index.html">SymPy 1.9 documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="../../index.html" >SymPy Modules Reference</a> &#187;</li>
          <li class="nav-item nav-item-2"><a href="../index.html" >Physics</a> &#187;</li>
          <li class="nav-item nav-item-3"><a href="index.html" >Continuum Mechanics</a> &#187;</li>
        <li class="nav-item nav-item-this"><a href="#">Beam (Docstrings)</a></li> 
      </ul>
    </div>
    <div class="footer" role="contentinfo">
        &#169; Copyright 2021 SymPy Development Team.
      Last updated on Sep 30, 2021.
      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 4.1.2.
    </div>
  </body>

<!-- Mirrored from docs.sympy.org/latest/modules/physics/continuum_mechanics/beam.html by HTTrack Website Copier/3.x [XR&CO'2014], Sat, 15 Jan 2022 03:27:29 GMT -->
</html>